package top.lixunda.ecommerce.server.good.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import top.lixunda.commerce.common.core.entity.MessageObject;
import top.lixunda.common.utils.ObjectValidators;
import top.lixunda.common.validate.XumValid;
import top.lixunda.ecommerce.server.business.BaseController;
import top.lixunda.ecommerce.server.good.api.entity.db.GoodsDO;
import top.lixunda.ecommerce.server.good.api.entity.dto.*;
import top.lixunda.ecommerce.server.business.api.entity.dto.PageDTO;
import top.lixunda.ecommerce.server.good.api.entity.vo.GoodGroupVO;
import top.lixunda.ecommerce.server.good.api.entity.vo.GoodsStoreVO;
import top.lixunda.ecommerce.server.good.api.entity.vo.GoodsVO;
import top.lixunda.ecommerce.server.good.api.controller.IGoodsController;
import top.lixunda.ecommerce.server.good.api.entity.vo.SysGoodCategoryVO;
import top.lixunda.ecommerce.server.good.service.IGoodsService;

import java.math.BigDecimal;
import java.util.*;

/**
 * @author Xumda
 * @version time:2020/1/10 14:58
 */
@Slf4j
@RestController
public class GoodsController extends BaseController
        implements IGoodsController {

    private final IGoodsService goodsService;

    @Autowired
    public GoodsController(IGoodsService goodsService) {
        this.goodsService = goodsService;
    }

    /**
     * 根据id获取商品数据
     * 只能查询普通用户可见的商品信息
     *
     * @param id 商品id
     * @return 商品列表
     */
    @Override
    public MessageObject<GoodsVO> queryById(Integer id) {
        if (id == null || id <= 0) {
            return getErrorMessageObject("参数id不能为空或小于等于零");
        }
        List<GoodsDO> goodsDoList = goodsService.queryByIds(Collections.singletonList(id));
        if (ObjectValidators.isEmpty(goodsDoList)) {
            return getErrorMessageObject("商品不存在");
        }
        GoodsVO goodsVO = GoodsVO.fromGoodsDO(goodsDoList).get(0);
        return getSuccessMessageObject("获取商品数据成功", goodsVO);
    }

    /**
     * 根据id获取多个商品数据
     * 只能查询普通用户可见的商品信息
     *
     * @param ids 商品id列表
     * @return 商品列表
     */
    @Override
    public MessageObject<List<GoodsVO>> queryByIds(List<Integer> ids) {
        if (ObjectValidators.isEmpty(ids)) {
            return getErrorMessageObject("参数ids不能为空");
        }
        List<GoodsDO> goodsDoList = goodsService.queryByIds(ids);
        if (ObjectValidators.isEmpty(goodsDoList)) {
            return getErrorMessageObject("商品不存在");
        }
        List<GoodsVO> goodsVoList = GoodsVO.fromGoodsDO(goodsDoList);
        return getSuccessMessageObject("获取商品数据成功", goodsVoList);
    }

    /**
     * 根据条件筛选商品信息，需要分页
     * 只能查询普通用户可见的商品信息
     *
     * @param pageDTO 查询条件DTO
     * @return 商品列表
     */
    @Override
    public MessageObject<IPage<GoodsVO>> queryGoodsByPageWrapper(
            @XumValid PageDTO<GoodsDO, GoodsQueryDTO> pageDTO) {
        IPage<GoodsDO> page = goodsService.queryGoodsByPage(pageDTO);
        IPage<GoodsVO> resultPage = pageConvert(page, GoodsVO::fromGoodsDO);
        return getSuccessMessageObject("获取商品数据成功", resultPage);
    }

    /**
     * 根据id获取商品数据，商家端调用，只能查询该店铺的商品信息
     *
     * @param id 商品id
     * @return 商品列表
     */
    @Override
    public MessageObject<GoodsStoreVO> queryByIdStore(Integer id) {
        if (id == null || id <= 0) {
            return getErrorMessageObject("参数id不能为空或小于等于零");
        }
        List<GoodsDO> goodsDoList = goodsService.queryByIdsStore(Collections.singletonList(id));
        if (ObjectValidators.isEmpty(goodsDoList)) {
            return getErrorMessageObject("商品不存在");
        }
        GoodsStoreVO goodsVO = GoodsStoreVO.fromGoodsDO(goodsDoList).get(0);
        return getSuccessMessageObject("获取商品数据成功", goodsVO);
    }

    /**
     * 根据id获取多个商品数据
     * 商家端调用，只能查询该店铺的商品信息
     *
     * @param ids 商品id列表
     * @return 商品列表
     */
    @Override
    public MessageObject<List<GoodsStoreVO>> queryByIdsStore(List<Integer> ids) {
        if (ObjectValidators.isEmpty(ids)) {
            return getErrorMessageObject("参数ids不能为空");
        }
        List<GoodsDO> goodsDoList = goodsService.queryByIdsStore(ids);
        if (ObjectValidators.isEmpty(goodsDoList)) {
            return getErrorMessageObject("商品不存在");
        }
        List<GoodsStoreVO> goodsVoList = GoodsStoreVO.fromGoodsDO(goodsDoList);
        return getSuccessMessageObject("获取商品数据成功", goodsVoList);
    }

    /**
     * 根据条件筛选商品信息，需要分页
     * 商家端调用，只能查询该店铺的商品信息
     *
     * @param pageDTO 查询条件DTO
     * @return 商品列表
     */
    @Override
    public MessageObject<IPage<GoodsStoreVO>> queryGoodsByPageWrapperStore(
            @XumValid PageDTO<GoodsDO, GoodsStoreQueryDTO> pageDTO) {
        IPage<GoodsDO> page = goodsService.queryGoodsByPageWrapperStore(pageDTO);
        IPage<GoodsStoreVO> resultPage = pageConvert(page, GoodsStoreVO::fromGoodsDO);
        return getSuccessMessageObject("获取商品数据成功", resultPage);
    }

    /**
     * 根据id获取商品数据
     * 管理员端调用，可以查询所有商品信息
     *
     * @param id 商品id
     * @return 商品列表
     */
    @Override
    public MessageObject<GoodsVO> queryByIdAdmin(Integer id) {
        if (id == null || id <= 0) {
            return getErrorMessageObject("参数id不能为空或小于等于零");
        }
        List<GoodsDO> goodsDoList = goodsService.queryByIdsAdmin(Collections.singletonList(id));
        if (ObjectValidators.isEmpty(goodsDoList)) {
            return getErrorMessageObject("商品不存在");
        }
        GoodsVO goodsVO = GoodsVO.fromGoodsDO(goodsDoList).get(0);
        return getSuccessMessageObject("获取商品数据成功", goodsVO);
    }

    /**
     * 根据id获取多个商品数据
     * 管理员端调用，可以查询所有商品信息
     *
     * @param ids 商品id列表
     * @return 商品列表
     */
    @Override
    public MessageObject<List<GoodsVO>> queryByIdsAdmin(List<Integer> ids) {
        if (ObjectValidators.isEmpty(ids)) {
            return getErrorMessageObject("参数ids不能为空");
        }
        List<GoodsDO> goodsDoList = goodsService.queryByIdsAdmin(ids);
        if (ObjectValidators.isEmpty(goodsDoList)) {
            return getErrorMessageObject("商品不存在");
        }
        List<GoodsVO> goodsVoList = GoodsVO.fromGoodsDO(goodsDoList);
        return getSuccessMessageObject("获取商品数据成功", goodsVoList);
    }

    /**
     * 根据条件筛选商品信息，需要分页
     * 管理员端调用，可以查询所有商品信息
     *
     * @param pageDTO 查询条件DTO
     * @return 商品列表
     */
    @Override
    public MessageObject<IPage<GoodsVO>> queryGoodsByPageWrapperAdmin(
            @XumValid PageDTO<GoodsDO, GoodsAdminQueryDTO> pageDTO) {
        IPage<GoodsDO> page = goodsService.queryGoodsByPageWrapperAdmin(pageDTO);
        IPage<GoodsVO> resultPage = pageConvert(page, GoodsVO::fromGoodsDO);
        return getSuccessMessageObject("获取商品数据成功", resultPage);
    }

    /**
     * 添加商品新的商品数据
     *
     * @param files 商品图片
     * @param goodsInsertDTO 商品数据
     * @return 返回是否添加成功
     */
    @Override
    public MessageObject<Boolean> addGood(MultipartFile[] files,
                                          @XumValid GoodsInsertDTO goodsInsertDTO) {
        Boolean success = goodsService.addGood(files, goodsInsertDTO);
        return getSuccessMessageObject("添加商品成功", success);
    }

    /**
     * 修改商品信息DTO
     *
     * @param files 需要添加的商品图片
     * @param goodsChangeDTO 修改的商品数据
     * @return 是否修改成功
     */
    @Override
    public MessageObject<Boolean> changeGood(MultipartFile[] files,
                                             @XumValid GoodsChangeDTO goodsChangeDTO) {
        Boolean success = goodsService.changeGood(files, goodsChangeDTO);
        return getSuccessMessageObject("更新商品数据成功", success);
    }

    /**
     * 根据id移除商品信息，店铺调用，只能移除自己店铺的商品数据
     *
     * @param ids 商品id
     * @return 是否移除成功
     */
    @Override
    public MessageObject<Boolean> removeGoodsByIds(List<Integer> ids) {
        Boolean success = goodsService.removeGoodsByIds(ids);
        return getSuccessMessageObject("移除商品数据成功", success);
    }

    /**
     * 根据子商品id列表移除子商品数据，店铺调用，只能移除自己店铺的商品数据，且移除后该商品至少包含一个子商品
     *
     * @param ids 子商品id列表
     * @return 是否移除成功
     */
    @Override
    public MessageObject<Boolean> removeSubGoodsByIds(List<Integer> ids) {
        Boolean success = goodsService.removeSubGoodsByIds(ids);
        return getSuccessMessageObject("移除数据成功", success);
    }

    /**
     * 店铺调用，查询当前店铺中商品的所有Category信息
     *
     * @return List<SysGoodCategoryVO>
     */
    @Override
    public MessageObject<List<SysGoodCategoryVO>> queryStoreGoodCategory() {
        List<SysGoodCategoryVO> list = goodsService.queryStoreGoodCategory();
        return getSuccessMessageObject("获取数据成功", list);
    }

    /**
     * 店铺调用，查询当前店铺中商品的所有Group信息
     *
     * @return List<SysGoodCategoryVO>
     */
    @Override
    public MessageObject<List<GoodGroupVO>> queryStoreGoodGroup() {
        List<GoodGroupVO> list = goodsService.queryStoreGoodGroup();
        return getSuccessMessageObject("获取数据成功", list);
    }

    /**
     * 店铺调用，查询当前店铺中商品的所有SellPoint信息
     *
     * @return List<SysGoodCategoryVO>
     */
    @Override
    public MessageObject<List<String>> queryStoreGoodSellPoint() {
        List<String> list = goodsService.queryStoreGoodSellPoint();
        return getSuccessMessageObject("获取数据成功", list);
    }

    /**
     * 店铺调用，查询当前店铺中商品的所有Freight信息
     *
     * @return List<SysGoodCategoryVO>
     */
    @Override
    public MessageObject<List<BigDecimal>> queryStoreGoodFreight() {
        List<BigDecimal> list = goodsService.queryStoreGoodFreight();
        return getSuccessMessageObject("获取数据成功", list);
    }

    /**
     * 店铺调用，查询当前店铺中商品的部分信息筛选项
     *
     * @return Map String,List
     */
    @Override
    public MessageObject<Map<String, Set>> queryStoreGoodTableFilter() {
        Map<String, Set> map = goodsService.queryStoreGoodTableFilter();
        return getSuccessMessageObject("获取数据成功", map);
    }

    /**
     * 店铺调用，提交商品进行审核
     *
     * @param ids 商品数据id列表
     * @return 是否提交申请成功
     */
    @Override
    public MessageObject<Boolean> pushGoodsCheckPending(List<Integer> ids) {
        Boolean success = goodsService.pushGoodsCheckPending(ids);
        return success ? getSuccessMessageObject("提交审核成功", true) :
                getErrorMessageObject("提交审核数据失败", false);
    }

    /**
     * 店铺调用，取消提交的商品审核
     *
     * @param ids 商品数据id列表
     * @return 是否成功取消
     */
    @Override
    public MessageObject<Boolean> cancelGoodsCheckPending(List<Integer> ids) {
        Boolean success = goodsService.cancelGoodsCheckPending(ids);
        return success ? getSuccessMessageObject("撤销审核成功", true) :
                getErrorMessageObject("撤销审核失败", false);
    }

    /**
     * 店铺调用，上架商品
     *
     * @param ids 商品数据id列表
     * @return 是否上架成功
     */
    @Override
    public MessageObject<Boolean> pushGoods(List<Integer> ids) {
        Boolean success = goodsService.pushGoods(ids);
        return success ? getSuccessMessageObject("上架商品成功", true) :
                getErrorMessageObject("上架商品失败", false);
    }

    /**
     * 店铺调用，下架商品
     *
     * @param ids 商品数据id列表
     * @return 是否下架成功
     */
    @Override
    public MessageObject<Boolean> pullGoods(List<Integer> ids) {
        Boolean success = goodsService.pullGoods(ids);
        return success ? getSuccessMessageObject("下架商品成功", true) :
                getErrorMessageObject("下架商品失败", false);
    }

    /**
     * 管理员调用，审核添加的商品
     *
     * @param list 审核数据信息
     * @return 审核结果
     */
    @Override
    public MessageObject<Boolean> checkingGoods(List<AdminCheckingDTO> list) {
        Boolean success = goodsService.checkingGoods(list);
        return success ? getSuccessMessageObject("提交审核数据成功", true) :
                getErrorMessageObject("提交审核数据失败", false);
    }

}
